package cube.cubetest;
/*
 * Copyright (C) 2007 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;

import android.opengl.GLSurfaceView;

//use the openGL renderer 
class InitCube implements GLSurfaceView.Renderer { //!
	//define variables 
	private boolean mTranslucentBackground;
	private CubeStore currentState;
	private CubeStore lastState; 
	private int bob; 
	private boolean finished; 
	private float shift; 
	//Let Activity decide whether to use translucent background or not 
    public InitCube(boolean useTranslucentBackground) {
        mTranslucentBackground = useTranslucentBackground;
        //generate graphics  
        currentState = new CubeStore(); 
        bob=0;
        shift=0;
    }
    
    //Called when the surface is first created 
    public void onSurfaceCreated(GL10 gl, EGLConfig config) {
        /*
         * By default, OpenGL enables features that improve quality
         * but reduce performance. One might want to tweak that
         * especially on software renderer.
         */
    	//You probably want this on the nexus cus graphics suck! 
        gl.glDisable(GL10.GL_DITHER);
        
        /*
         * Some one-time OpenGL initialization can be made here
         * probably based on features of this particular context
         */
         gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT,
                 GL10.GL_FASTEST);

         if (mTranslucentBackground) {
             gl.glClearColor(0,0,0,0);
         } else {
             gl.glClearColor(1,1,1,1);
         }
         //gl.glEnable(GL10.GL_CULL_FACE);
         gl.glShadeModel(GL10.GL_SMOOTH);
         gl.glEnable(GL10.GL_DEPTH_TEST);
    }
    //draw the current frame 
    public void onDrawFrame(GL10 gl) {
        /*
         * Usually, the first thing one might want to do is to clear
         * the screen. The most efficient way of doing this is to use
         * glClear().
         */
    	switch (bob) {
    		case 1:
    			finished = currentState.rotateTop(true, gl, false);
    			if (finished) { 
    				bob=3;
    			}
    			
    			break;
    		case 0:
    			currentState.drawInit(gl);
    			break;
    			default:
    				currentState.repeatLast(gl);
    			break;
    	}
    }
    
    public void rotateTop(boolean clockwise) { 
    	bob=1;
    }

    //called when the surface changed size 
    public void onSurfaceChanged(GL10 gl, int width, int height) {
         gl.glViewport(0, 0, width, height);
         /*
          * Set our projection matrix. This doesn't have to be done
          * each time we draw, but usually a new projection needs to
          * be set when the viewport is resized.
          */
         float ratio = (float) width / height;
         gl.glMatrixMode(GL10.GL_PROJECTION);
         gl.glLoadIdentity();
         gl.glFrustumf(-ratio, ratio, -1, 1, 1, 10);
    }
    
}
